The present invention pertains to the field of computer system architecture. More specifically, the present invention pertains to a method for using shared memory to facilitate message exchanges and data transfer in a computer system or in a network of computer systems.
A typical computer system utilizes a variety of software elements such as an operating system, device drivers, application programs (xe2x80x9capplicationsxe2x80x9d) including computer software programs, word processors, database management systems, electronic mail, and the like, and communication programs that execute communication protocols that define the procedures to be followed when data are transmitted and received.
The software elements in a computer system, and the software elements on different computer systems, use data packets to communicate with each other and exchange information. Sending and receiving is accomplished using software processes such as applications, threads, drivers, protocol stacks, and the like. In the prior art, software is involved at both ends of any message exchange or data transmission, whether it is a one-way exchange (for example, from one computer system to another), two-way (for example, from one computer system to another and back again), and so on. For example, a source software element sends data packets to a target software element in order to issue requests and commands, such as a command to execute a particular application. In response to these requests and commands, the target software element sends an acknowledgment data packet (xe2x80x9cacknowledgmentxe2x80x9d) to the source software element to indicate that the request or command was properly received, as well as responses to the requests and commands.
The focus of this discussion of the prior art is not the data processing accomplished by the software, but rather the involvement of the software in the data/message exchanges. The problem with these kinds of exchanges (with software elements involved at each end of the exchange) is that they consume processing cycles and memory resources in the computer systems involved in the exchange. In addition, the exchanges can only be accomplished at the rate at which the software can handle the data/message.
By way of exemplifying the problems with the prior art, consider the current process for sending and receiving acknowledgments in response to requests and commands. Prior Art FIG. 1 is a diagram showing a first computer system 80a communicatively coupled to a second computer system 80b in computer system network 30. The software elements executed by computer system 80a are represented by application layer A 10. In a similar manner, computer system 80b includes application layer B 60.
One of the software elements (e.g., from application layer A 10) of computer system 80a transmits to computer system 80b a data packet (e.g., message 90) containing, for example, a command or request. Computer system 80b responds to message 90 in the form of acknowledgment 95. Typically, a prescribed number of messages are sent by the source software element before an acknowledgment is provided by the target software element. For example, ten (10) messages may be sent from the source software element (e.g., from application layer A 10) before an acknowledgment is required from the target software element (e.g., from application layer B 60). The source software element will not transmit any further messages until it receives an acknowledgment. After receiving an acknowledgment, the source software element transmits another 10 messages.
In the prior art, message 90 is placed in a buffer (e.g., message queue B 22) of computer system 80b before it is eventually forwarded to application layer B 60, and similarly acknowledgment 95 is placed in a buffer (e.g., message queue A 20) of computer system 80a before it is eventually forwarded to application layer A 10. When a plurality of messages and acknowledgments are sent between computer systems 80a and 80b, in particular between the software elements on these computer systems, the message queues are used to control the flow of the messages and acknowledgments to the particular software elements.
A disadvantage to the prior art is that the resources of the computer system that processes the acknowledgments (e.g., computer systems 80a and 80c) are consumed by the operations associated with adding and removing acknowledgments from the message queues. For example, the computer system needs to establish field lengths for storing the acknowledgments and then needs to write the acknowledgments to the message queue. The computer system needs to synchronize the source and target software elements. It is sometimes necessary for the computer system to copy the acknowledgment before removing it from the message queue. Also, the computer system needs to specify and move pointers. Thus, the prior art techniques for processing acknowledgments consume a computer system""s processing cycles and memory resources in order to complete the required operations.
The discussion above can be readily extrapolated to the exchange of other types of messages and to data transmission in the prior art. For example, a command or request from one computer system to a second computer system is placed into a queue, and there is overhead associated with processing the exchange. The prior art techniques for message exchange and data transmission require a significant amount of processing overhead, and hence the overall performance of the computer system can be significantly reduced.
Accordingly, what is needed is a method to reduce the processing overhead associated with message exchange and data transmission. What is further needed is a method to improve the overall performance of the computer system in this regard. The present invention provides a novel solution to the above needs.
These and other objects and advantages of the present invention will become obvious to those of ordinary skill in the art after having read the following detailed description of the preferred embodiments which are illustrated in the various drawing figures.
The present invention provides a method to reduce the processing overhead associated with message exchange and data transmission, and improves the overall performance of the computer system in this regard.
The present invention pertains to a method for exchanging messages between software elements in computer systems communicatively coupled in a computer system network. A message is sent from a software element of a first computer system (e.g., a client computer system) to a second computer system (e.g., a server computer system). A shared memory unit of the second computer system is directly accessed, bypassing the processor of the second computer system. The shared memory unit is accessible by the software element of the first computer system and a software element of the second computer system. Data of interest are directly read from or written to the shared memory unit.
In one embodiment, the present invention pertains to a method for acknowledging messages between a first software element and a second software element. A plurality of messages is sent from the first software element to the second software element. A count of each of the plurality of messages sent by the first software element is maintained. A message is written from the second software element to a memory unit shared by the first software element and by the second software element when the count reaches a prescribed number. The message from the second software element acknowledges receipt of the prescribed number of messages from the first software element.